/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package cuatroenraya.jugadores;


import cuatroenraya.util.HeuristicaList;
import java.util.ArrayList;

/**
 *
 * @author Dario
 */
public class Arbol {

    private Node raiz;  // Start node
    private int auxPuntuacion;
    private int[] jugadaSeleccionada;
    int FichaJugador = 2;
    int FichaOponente = 1;
    boolean jugadaEncontrada = false;
    public boolean Defender;
    public static ArrayList<Posicion> misFichas = new ArrayList<Posicion>();
    public static ArrayList<Posicion> fichasOponente = new ArrayList<Posicion>();
    ;
    public static ArrayList<Node> Hijos = new ArrayList<Node>();
    public static ArrayList<ArrayList<Node>> Nietos =
            new ArrayList<ArrayList<Node>>();
    private static final int TOTAL_ELEMENTOS = 64;
    public static ArrayList<HeuristicaList> hlNietos =
            new ArrayList<HeuristicaList>();

    public Arbol() {
    }

    public void crearRaiz(int[][] tablero, int fichaJugador, int fichaOponente) {

        FichaJugador = fichaJugador;
        FichaOponente = fichaOponente;
        raiz = new Node(tablero, FichaJugador);
    }

    

    public void cargarArbol(boolean esMover) {
        int vacios = Arbol.getVacios();
        if (!esMover) {
            Posicion paux = new Posicion(0, 0);
            for (int i = 0; i < vacios; i++) {
                paux = raiz.addNodoHijosInsertar(raiz, FichaJugador, paux);
            }
            ArrayList<Node> hijos = new ArrayList<Node>();
            hijos = (ArrayList<Node>) Hijos.clone();
            Hijos.clear();
            System.out.println(hijos.size());
            ArrayList<Node> nietos = null;
            Node.setHl(new HeuristicaList());
            for (Node nHijo : hijos) {
                if (fichasOponente.size() < 5) {
                    Posicion phijo = new Posicion(0, 0);
                    for (int j = 0; j < vacios - 1; j++) {
                        phijo = nHijo.addNodoHijosInsertar(nHijo, FichaOponente,
                                phijo);
                    }
                } else {
                    nHijo.addNodoHijosMover(nHijo, FichaOponente, true);
                }
                nietos = new ArrayList<Node>();
                nietos = (ArrayList<Node>) Hijos.clone();
                Hijos.clear();
                HeuristicaList hlaux = Node.getHl();
                hlaux.imprimirOrdenada();
                hlNietos.add(hlaux);
                Node.setHl(new HeuristicaList());
            }
            Nietos.add(nietos);
            Hijos = (ArrayList<Node>) hijos.clone();


        } else {
            raiz.addNodoHijosMover(raiz, FichaJugador, false);
            ArrayList<Node> hijos = new ArrayList<Node>();
            hijos = (ArrayList<Node>) Hijos.clone();
            Hijos.clear();
            System.out.println(hijos.size());
            ArrayList<Node> nietos = null;
            Node.setHl(new HeuristicaList());
            for (Node nHijo : hijos) {
                if (fichasOponente.size() < 5) {
                    Posicion phijo = new Posicion(0, 0);
                    for (int j = 0; j < vacios - 1; j++) {
                        phijo = nHijo.addNodoHijosInsertar(nHijo, FichaOponente,
                                phijo);
                    }
                } else {
                    nHijo.addNodoHijosMover(nHijo, FichaOponente, true);
                }
                nietos = new ArrayList<Node>();
                nietos = (ArrayList<Node>) Hijos.clone();
                Hijos.clear();
            }
            Nietos.add(nietos);
            Hijos = (ArrayList<Node>) hijos.clone();
            HeuristicaList hlaux = Node.getHl();
            hlaux.imprimirOrdenada();
            hlNietos.add(hlaux);
            hlaux = new HeuristicaList();
            Node.setHl(hlaux);
        }

    }

    public static ArrayList<Node> getHijos() {
        return Hijos;
    }

    public static void setHijos(ArrayList<Node> Hijos) {
        Arbol.Hijos = Hijos;
    }

    public static void setHijo(Node hijos) {
        Arbol.Hijos.add(hijos);
    }

    public static ArrayList<Posicion> getFichasOponente() {
        return fichasOponente;
    }

    public static void setFichasOponente(ArrayList<Posicion> fichasOponente) {
        Arbol.fichasOponente = fichasOponente;
    }

    public static ArrayList<Posicion> getMisFichas() {
        return misFichas;
    }

    public static void setMisFichas(ArrayList<Posicion> misFichas) {
        Arbol.misFichas = misFichas;
    }

    public static int getVacios() {
        return TOTAL_ELEMENTOS - (misFichas.size() + fichasOponente.size());
    }

    public Arbol(Node nuevaRaiz, int set_fichaJugador) {
        raiz = nuevaRaiz;
        this.FichaJugador = set_fichaJugador;
    }

    void add_Nodo(int[][] tablero, int[] jugada, boolean esMover) {
        //raiz.add(tablero, jugada, FichaJugador, esMover);
    }

    Node get_Nodo(int i) {
        return raiz.getNodo(i);
    }

    Node get_Raiz() {
        return raiz;
    }

    public int[] get_MejorJugada() {
        auxPuntuacion = 0;
        recorrerArbol(raiz);
        if (jugadaEncontrada == false) {
            jugadaSeleccionada[0] = 0;
            jugadaSeleccionada[0] = 0;
            jugadaSeleccionada[0] = 0;
            jugadaSeleccionada[0] = 1;

        }
        return jugadaSeleccionada;
    }

    private void recorrerArbol(Node n) {
//        for (int j = 0; j < n.cantidadHijos(); j++) {
//            recorrerNodo(n.getNodo(j).getThis());
//        }
    }

    private void recorrerNodo(Node n) {
        // System.out.println (n.toString());
        if (auxPuntuacion <= n.Puntuacion) {
            if (jugadaEncontrada == false) {
                jugadaEncontrada = true;
                auxPuntuacion = n.Puntuacion;
//                jugadaSeleccionada = n.getJugada();
            } else {
                //Evaluar nuevas Alternativas: Solo en Ataque
                if (Defender == false) {
                    int opcion = 0;
                    opcion = aleatorio(1, 3);
                    if (opcion == 1) {
                        auxPuntuacion = n.Puntuacion;
                        jugadaEncontrada = true;
//                        jugadaSeleccionada = n.getJugada();
                    }
                }
            }
        }

        for (Node h : n.Hijos) {
            recorrerNodo(h);//cortar el recorrido del arbol. Ordenar por heuristica.
        }

    }

    private int aleatorio(int min, int max) {
        return (int) (Math.random() * (max - min)) + min;
    }
    // fin del class Arbol
}
